﻿#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

using namespace std;

////基类/父类
//class Person
//{
//public:
//	void Print()
//	{
//		cout << "name: " << _name << endl;
//		cout << "age: " << _age << endl;
//	}
////protected:
//private:
//	string _name = "Peter";
//	int _age = 18;
//};
//
//class Student : public Person
//{
//public:
//	void func()
//	{
//		//cout << _name << endl;
//	}
//
//protected:
//	int _stuid;
//};
//
//class Teacher : public Person
//{
//protected:
//	int _jobid;
//};


//int main()
//{
//	double d = 1.1;
//
//	int i = d;//隐式类型转换
//	const int& ri = d;
//
//	Student s;
//	Person p = s;//天然支持的，不存在隐式类型转换
//	Person& rp = s;
//	Person* ptr = &s;
//
//	return 0;
//}

//class Person
//{
//protected:
//	string _name = "小李子";
//	int _num = 111;
//};
//
//class Student : public Person
//{
//public:
//	void Print()
//	{
//		cout << "姓名：" << _name << endl;
//		cout << "身份证号: " << Person::_num << endl;
//		cout << "学号: " << _num << endl;
//	}
//protected:
//	int _num = 999;
//};

//class A
//{
//public:
//	void func()
//	{
//		cout << "func()" << endl;
//	}
//};
//
//class B : public A
//{
//public:
//	void func(int i)
//	{
//		A::func();
//		cout << "func(int i)" << endl;
//	}
//};
//
//void Test()
//{
//	B b;
//	b.func(10);
//	b.A::func();
//}

class Person
{
public:
	Person(const char* name = "peter")
		: _name(name)
	{
		cout << "Person()" << endl;
	}

	Person(const Person& p)
		: _name(p._name)
	{
			cout << "Person(const Person& p)" << endl;
	}

	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; //姓名
};

class Student : public Person
{
public:
	// 父类构造显示调用，可以保证先父后子
	Student(const char* name = "", int x = 0, const char* address = "")
		:_x(x)
		, _address(address)
		, _name(Person::_name + 'x')
		, Person(name)
	{}

	Student(const Student& st)
		:Person(st)
		, _x(st._x)
		, _address(st._address)
	{}

	Student& operator=(const Student& st)
	{
		if (this != &st)
		{
			Person::operator=(st);
			_x = st._x;
			_address = st._address;
		}

		return *this;
	}

	// 由于多态，析构函数的名字会被统一处理成destructor()

	// 父类析构不能显示调用，因为显示调用不能保证先子后父
	~Student()
	{
		// 析构函数会构成隐藏，所以这里要指定类域
		//Person::~Person();

		cout << "~Student()" << endl;
		// delete [] _ptr;
		//cout << _str << endl;
	}

protected:
	int _x = 1;
	string _address = "西安高新区";
	string _name;

	//int* _ptr = new int[10];
};

//class Student : public Person
//{
//public:
//	Student(const char* name = "", int x = 0, const char* address = "")
//		:_x(x)
//		, _address(address)
//		, _name(Person::_name + 'x')
//		, Person(name)
//	{}
//
//	Student(const Student& st)
//		:Person(st),
//		_x(st._x),
//		_address(st._address)
//	{}
//
//	Student& operator=(const Student& st)
//	{
//		if (this != &st)
//		{
//			Person::operator=(st);
//
//			_x = st._x;
//			_address = st._address;
//		}
//
//		return *this;
//	}
//	
//	~Student()
//	{
//		Person::~Person();
//		cout << "~Student()" << endl;
//	}
//
//protected:
//	int _x;
//	string _address;
//};

int main()
{
	Student s;
}

//
//
//class Student : public Person
//{
//public:
//	//父类的构造会默认调用父类的构造函数
//	//所以我们想要初始化父类的成员变量要在初始化列表调用父类的构造函数
//	//这里规定父类的成员必须调用父类的构造函数初始化
//	Student(const char* name,int num)
//		:Person(name),
//		_num(num)
//		
//	{	
//		cout << "Student(const char* name,int num)" << endl;
//	}
//
//	Student(const Student& s)
//		:
//		_num(s._num)
//	{
//		cout << "Student(const Student& s)" << endl;
//	}
//
//	Student& operator=(const Student& s)
//	{
//		if (this != &s)
//		{
//			Person::operator=(s);
//			_num = s._num;
//		}
//
//		cout << "Student& operator=(const Student& s)" << endl;
//
//		return *this;
//	}
//
//	~Student()
//	{
//		cout << "~Student()" << endl;
//	}
//
//protected:
//	int _num; //学号
//};
//
//int main()
//{
//
//	Student s("张三",18);
//	Student s1(s);
//
//
//	string s;
//
//	//s1 = s;
//	return 0;
//}

/*class Student;
class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name;

};

class Student : public Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	int _stuNum;
};

void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;
	cout << s._stuNum << endl;
}*/


//class A
//{
//	// 声明B是A的友元类
//	friend class B;
//public:
//	A(int n = 0)
//		:_n(n)
//	{}
//private:
//	int _n;
//};
//class B
//{
//public:
//	void Test(A& a)
//	{
//		// B类可以直接访问A类中的私有成员变量
//		cout << a._n << endl;
//	}
//};
//
//class Person
//
//
//int main()
//{
//	A a;
//	B b;
//	b.Test(a);
//}

//class Person
//{
//public:
//	Person()
//	{
//		++_count;
//	}
////protected:
//	string _name;
//public:
//	static int _count;
//};

//int Person::_count = 0;
//
//class Student : public Person
//{
//protected:
//	int _stuid;
//};
//
//class Graduate : public Student
//{
//protected:
//	string _seminarCourse;
//};

//int main()
//{
//	Person p;
//	Student s;
//
//	cout << &(p._name) << endl;
//	cout << &(s._name) << endl;
//
//	cout << &(p._count) << endl;
//	cout << &(s._count) << endl;
//
//	Graduate g1;
//	Graduate g2;
//
//	cout << Person::_count << endl;
//	cout << Graduate::_count << endl;
//}

//实现一个不能被继承的类
class A
{
public:
	static A GreateObj()
	{
		return A();
	}
private:
	A()
	{}
};

class B : public A
{};

//int main()
//{
//	//B b;
//
//	A a = A::GreateObj();
//}

//class Person
//{
//public:
//
//};
//
//class Time
//{
//	friend class Date;
//public:
//	Time(int hour = 0, int minute = 0, int second = 0)
//		: _hour(hour)
//		, _minute(minute)
//		, _second(second)
//	{
//		cout << "Time(int hour = 0, int minute = 0, int second = 0)" << endl;
//	}
//
//	Time(const Time& t)
//		: _hour(t._hour)
//		, _minute(t._minute)
//		, _second(t._second)
//	{
//		cout << "Time(const Time& t)" << endl;
//	}
//
//private:
//	int _hour;
//	int _minute;
//	int _second;
//};
//
//class Date
//{
//public:
//	Date(int year = 1900, int month = 1, int day = 1)
//		: _year(year)
//		, _month(month)
//		, _day(day)
//	{}
//
//	void SetTimeOfDate(int hour, int minute, int second)
//	{
//		_t._hour = hour;
//		_t._minute = minute;
//		_t._second = second;
//	}
//
//	Date(const Date& d)
//	{
//
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//	Time _t;
//};
//
//int main()
//{
//	Date d;
//	Date d1(d);
//}

//class Person
//{
//public:
//	string _name;
//};

//class Student : virtual public Person
//{
//protected:
//	int _num;
//};
//
//class Teacher : virtual public Person
//{
//protected:
//	int _id;
//};
//
//class Assisant : public Student, public Teacher
//{
//protected:
//	int _id;
//};
//
//void Test()
//{
//	//这样会有二义性无法明确知道访问那一个
//	Assisant a;
//	//加访问限定符进行限制
//	a.Teacher::_name = "张三";
//	a.Student::_name = "李四";
//}
//
//int main()
//{
//	Test();
//}

//// Car和BMW Car和Benz构成is-a的关系
//class Car {
//protected:
//	string _colour = "白色"; // 颜色
//	string _num = "陕ABIT00"; // 车牌号
//};
//
//class BMW : public Car {
//public:
//	void Drive() { cout << "好开-操控" << endl; }
//};
//
//class Benz : public Car {
//public:
//	void Drive() { cout << "好坐-舒适" << endl; }
//};
//
// Tire和Car构成has-a的关系
//
//class Tire {
//protected:
//	string _brand = "Michelin";
//	size_t _size = 17;
//
//};
//
//
//class Car {
//protected:
//	string _colour = "白色"; // 颜色
//	string _num = "陕ABIT00"; // 车牌号
//	Tire _t; // 轮胎
//};